// 示例 1：
// 输入：num = 4, t = 1
// 输出：6
// 解释：最大可达成数字是 x = 6 ，执行下述操作可以使其等于 num ：
// - x 减少 1 ，同时 num 增加 1 。此时，x = 5 且 num = 5 。 
// 可以证明不存在大于 6 的可达成数字。

// 示例 2：
// 输入：num = 3, t = 2
// 输出：7
// 解释：最大的可达成数字是 x = 7 ，执行下述操作可以使其等于 num ：
// - x 减少 1 ，同时 num 增加 1 。此时，x = 6 且 num = 4 。 
// - x 减少 1 ，同时 num 增加 1 。此时，x = 5 且 num = 5 。 
// 可以证明不存在大于 7 的可达成数字。


//先乘除后加减
// var theMaximumAchievableX = function (num, t) {
//     return num + t * 2
// };
// console.log(theMaximumAchievableX(4,1));



// 给定一个整数数组 nums 和一个整数目标值 target， 请你在该数组中找出 和为目标值 target 的那 两个 整数， 并返回它们的数组下标。
// 你可以假设每种输入只会对应一个答案。 但是， 数组中同一个元素在答案里不能重复出现。
// 你可以按任意顺序返回答案。

// 示例 1：
// 输入： nums = [2, 7, 11, 15], target = 9
// 输出：[0, 1]
// 解释： 因为 nums[0] + nums[1] == 9， 返回[0, 1]。

// 示例 2：
// 输入： nums = [3, 2, 4], target = 6
// 输出：[1, 2]

// 示例 3：
// 输入： nums = [3, 3], target = 6
// 输出：[0, 1]


/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number[]}
 */
// var twoSum = function (nums, target) {
//     // 创建一个空的哈希表（对象）用于存储已经遍历过的数字及其对应的索引
//     var hashTable = {};

//     // 遍历数组nums的每一个元素及其索引
//     for (var i = 0; i < nums.length; i++) {
//         // 计算当前元素与目标值之间的差值
//         var complement = target - nums[i]; //9-2  9-7  9-11 9-15
//         // console.log(complement,"complement")

//         // 如果这个差值已经在哈希表中，说明我们找到了一对解，返回这对解的索引
//         if (hashTable.hasOwnProperty(complement)) {
//             return [hashTable[complement], i];
//         }

//         // 如果差值不在哈希表中，则将当前元素及其索引存入哈希表，供后续遍历中的元素匹配
//         hashTable[nums[i]] = i;
//         console.log(hashTable.hasOwnProperty, "hashTable")
//     }

//     // 如果没有找到符合条件的整数对，理论上题目保证有唯一解，所以这里不会执行到
//     // 但为了代码的完整性，可以抛出一个错误或者返回特定值
//     throw new Error("No two sum solution");
// };


// console.log(twoSum([3,2,4], 6));




// /**
//  * @param {number} x
//  * @return {boolean}
//  */
//  var isPalindrome = function(x) {
//     // 负数和以0开头的非零数都不是回文数
//     if (x < 0 || (x % 10 === 0 && x !== 0)) {
//         return false;
//     }

//     let revertedNumber = 0;
//     while (x > revertedNumber) {
//         // 将当前数的最后一位加到revertedNumber的末尾
//         revertedNumber = revertedNumber * 10 + x % 10;
//         // 去掉x的最后一个数字
//         x = Math.floor(x / 10);
//     }

//     // 当原数长度为奇数时，中间那位不需要考虑，直接和自身比较（比如121的中间是2）
//     // 当原数长度为偶数且经过上面的处理后x == revertedNumber，说明是回文（比如1221处理后x=12，revertedNumber=12）
//     // 当原数长度为偶数且经过上面的处理后x == revertedNumber/10，也说明是回文（比如12321处理到一半时x=12，revertedNumber=21）
//     return x === revertedNumber || x === Math.floor(revertedNumber / 10);
// };


// console.log(isPalindrome(12321))




// Array.prototype.last = function() {
//     console.log(this[this.length-1],"length")
//     return this.length ? this[this.length-1]: -1
// };


// const arr = [null,{},3];
// console.log(arr.last(),"arr");



// var createCounter = function(n) {
    
//     return function() {
//          return n++
//     };
// };
//  const counter = createCounter(10)
//  console.log(counter());


// async function sleep(millis) {
//     return new Promise(resolve => {
//         setTimeout(() => {
//             resolve()
//         }, millis)
//     })
// }

 
// let t = Date.now()
// console.log(sleep(100).then(() => console.log(Date.now() - t)))//100


// // 找出数组中的最小值
// let a = [1, 1, 2, 3, 1, 4, 4, 5, 6, 8,0]
// let min = (arr) =>{
//    let min=arr.reduce((min,next)=>{
//        return Math.min(min,next)
//    })
//    return min
// }
// console.log(min(a)) //8



// const arrayOfOne = new Array("2"); // 这里是字符串 "2" 而不是数字 2

// console.log(arrayOfOne.length); // 1
// console.log(arrayOfOne[0]); // "2"


const beasts = ['ant', 'bison', 'camel', 'duck', 'bison'];

console.log(beasts.indexOf('bison'));
// Expected output: 1

// Start from index 2
console.log(beasts.indexOf('bison', 2));
// Expected output: 4

console.log(beasts.indexOf('giraffe'));
// Expected output: -1